home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / usercio.c < prev    next >
Text File  |  1993-08-23  |  8KB  |  338 lines
  1. /* usercio.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. /*******************************************************************/
  25. /*                                                                 */
  26. /*    usercio.c -  Sample User IO program illustrating use of      */
  27. /*                 commands from NeuralWorks. A User program       */
  28. /*                 must provide all these functions                */
  29. /*                                                                 */
  30. /*    Author: John C. Fairman           August 31, 1990            */
  31. /*    Copyright 1990 by NeuralWare Inc.                            */
  32. /*                                                                 */
  33. /*    $Author   :  $                                               */
  34. /*    $Date     :  $                                               */
  35. /*    $Source   :  $                                               */
  36. /*    $Revision :  $                                               */
  37. /*    $Log      :  $                                               */
  38. /*                                                                 */
  39. /*******************************************************************/
  40.  
  41. #define UIO_SERVER             1
  42. #define SERVER_EMULATOR_FILE   1
  43. #define SKIP_COMPAT_DATA       1
  44. #include "userutl.h"
  45. #include "uio_strc.h"
  46. #include "uio_tran.h"
  47. #include "uio_reqs.pro"
  48. #include "uio_cmds.pro"
  49.  
  50. #ifdef MAC
  51. #include "macuio.redef"
  52. #endif
  53.  
  54. /*******************************************************************/
  55. /*                                                                 */
  56. /* Functions necessary for handling the User I/O package itself.   */
  57. /*                                                                 */
  58. /*******************************************************************/
  59.  
  60. /* FUNCTION */
  61. NINT UIO_Init(file)
  62. TEXT *file;
  63. {
  64.   NINT ret_val = UIO_OK;
  65.  
  66.  
  67.   /* USER TO PLACE CODE HERE */
  68.  
  69.   return(ret_val);
  70. }
  71.  
  72.  
  73. /* */
  74. /* FUNCTION */
  75. NINT UIO_Term(process)
  76. NINT process;
  77. {
  78.   PutStr( "bye bye\n" );
  79.  
  80.   return(UIO_OK);
  81. }
  82.  
  83.  
  84. /* FUNCTION */
  85. NINT UIO_Attention()
  86. {
  87.   NINT ret_val = UIO_OK;
  88.  
  89.  
  90.   /* USER TO PLACE CODE HERE */
  91.  
  92.   return(ret_val);
  93. }
  94.  
  95.  
  96. /*******************************************************************/
  97. /*                                                                 */
  98. /*  Functions necessary for handling a learning session.           */
  99. /*                                                                 */
  100. /*******************************************************************/
  101.  
  102. /* FUNCTION */
  103. NINT UIO_Learn_Start()
  104. {
  105.   ug_msgio( "Learning", 9, 1 );
  106.  
  107.   return(UIO_OK);
  108. }
  109.  
  110.  
  111. /* */
  112. /* FUNCTION */
  113. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  114. NINT  LayN;
  115. NINT  nPEs;
  116. SREAL *Datap;
  117. {
  118.         char *sp;       /* string pointer */
  119.         int   wx;       /* work index */
  120.  
  121.   NINT ret_val = UIO_OK;
  122.  
  123.   PutStr( "Enter Two Digits (ex: 00) as input or 'E' End XOR: " );
  124.   sp = GetStr();
  125.  
  126.   /* Terminate learning if user types 'E' */
  127.   if ( *sp == 'e' || *sp == 'E' ) {
  128.     ret_val = UIO_ERROR;
  129.     goto rtrn;
  130.   }
  131.  
  132.   for( wx=0; wx < nPEs; wx++, sp++ ) {
  133.       while( *sp != '\0' && *sp <= ' ' )
  134.     sp++;       /* skip white space */
  135.       if ( *sp == '\0' ) break;   /* no more data */
  136.       Datap[wx] = (*sp=='0'? 0.0:1.0);  /* set data */
  137.   }
  138.  
  139.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  140.  
  141.       rtrn:
  142.   return(ret_val);
  143. }
  144.  
  145.  
  146. /* FUNCTION */
  147. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  148. NINT  LayN;
  149. NINT  nPEs;
  150. SREAL *Datap;
  151. {
  152.         char *sp;       /* string pointer */
  153.         int   wx;       /* work index */
  154.   NINT ret_val = UIO_OK;
  155.  
  156.   PutStr( "Enter desired Output as a single digit: " );
  157.   sp = GetStr();
  158.  
  159.   wx = 0;
  160.   while( *sp != '\0' && *sp <= ' ' )
  161.       sp++;       /* skip white space */
  162.   Datap[wx++] = (*sp=='0'? 0.0:1.0);  /* set data */
  163.  
  164.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  165.  
  166.   return(ret_val);
  167. }
  168.  
  169.  
  170. /* */
  171. /* FUNCTION */
  172. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  173. NINT  LayN;
  174. NINT  nPEs;
  175. SREAL *Datap;
  176. {
  177.   NINT ret_val = UIO_OK;
  178.  
  179.  
  180.   /* USER TO PLACE CODE HERE */
  181.  
  182.   return(ret_val);
  183. }
  184.  
  185.  
  186. /* FUNCTION */
  187. NINT UIO_Learn_End()
  188. {
  189.   NINT ret_val = UIO_OK;
  190.  
  191.  
  192.   /* USER TO PLACE CODE HERE */
  193.  
  194.   return(ret_val);
  195. }
  196.  
  197.  
  198. /* */
  199. /*******************************************************************/
  200. /*                                                                 */
  201. /*  Functions necessary for handling a recall or testing session.  */
  202. /*                                                                 */
  203. /*******************************************************************/
  204.  
  205. /* FUNCTION */
  206. NINT UIO_Recall_Start()
  207. {
  208.   ug_msgio( "Recalling", 10, 1 );
  209.  
  210.   return(UIO_OK);
  211. }
  212.  
  213.  
  214. /* FUNCTION */
  215. NINT UIO_Read(LayN, nPEs, Datap)
  216. NINT  LayN;
  217. NINT  nPEs;
  218. SREAL *Datap;
  219. {
  220.   NINT ret_val = UIO_OK;
  221.  
  222.   return( UIO_Learn_Input(LayN, nPEs, Datap ) );
  223. }
  224.  
  225.  
  226. /* */
  227. /* FUNCTION */
  228. NINT UIO_Write(LayN, nPEs, Datap)
  229. NINT  LayN;
  230. NINT  nPEs;
  231. SREAL *Datap;
  232. {
  233.         char  buf[100];       /* work buffer */
  234.  
  235.   sprintf( buf, "Result is: %.3f\n", Datap[0] );
  236.   PutStr( buf );
  237.   return( UIO_UPDATE);      /* update display */
  238. }
  239.  
  240.  
  241. /* FUNCTION */
  242. NINT UIO_Write_Step(LayN, nPEs, Datap)
  243. NINT  LayN;
  244. NINT  nPEs;
  245. SREAL *Datap;
  246. {
  247.   NINT ret_val = UIO_OK;
  248.  
  249.  
  250.   /* USER TO PLACE CODE HERE */
  251.  
  252.   return(ret_val);
  253. }
  254.  
  255.  
  256. /* */
  257. /* FUNCTION */
  258. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  259. NINT  LayN;
  260. NINT  nPEs;
  261. SREAL *Datap;
  262. {
  263.         return(UIO_Learn_Output(LayN, nPEs, Datap));
  264. }
  265.  
  266. /* FUNCTION */
  267. NINT UIO_Recall_End()
  268. {
  269.   NINT ret_val = UIO_OK;
  270.  
  271.  
  272.   /* USER TO PLACE CODE HERE */
  273.  
  274.   return(ret_val);
  275. }
  276.  
  277.  
  278. /* */
  279. /*******************************************************************/
  280. /*                                                                 */
  281. /*  Other miscelaneous functions.                                  */
  282. /*                                                                 */
  283. /*******************************************************************/
  284.  
  285. /* FUNCTION */
  286. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  287. NINT  Instrument_id;
  288. NINT  nDataElems;
  289. SREAL *DataElemp;
  290. {
  291.   NINT ret_val = UIO_OK;
  292.  
  293.  
  294.   /* USER TO PLACE CODE HERE */
  295.  
  296.   return(ret_val);
  297. }
  298.  
  299.  
  300. /* FUNCTION */
  301. NINT UIO_ObjFunc(eoeflag, DataElemp)
  302. NINT  eoeflag;
  303. SREAL *DataElemp;
  304. {
  305.   NINT ret_val = UIO_OK;
  306.  
  307.   /* USER TO PLACE CODE HERE */
  308.  
  309.   return(ret_val);
  310. }
  311.  
  312. /* FUNCTION */
  313. NINT UIO_Rewind()
  314. {
  315.   NINT ret_val = UIO_OK;
  316.  
  317.  
  318.   /* USER TO PLACE CODE HERE */
  319.  
  320.   return(ret_val);
  321. }
  322.  
  323.  
  324. /* */
  325. /* FUNCTION */
  326. NINT UIO_Explain(LayN, nPEs, Datap)
  327. NINT  LayN;
  328. NINT  nPEs;
  329. SREAL *Datap;
  330. {
  331.   NINT ret_val = UIO_OK;
  332.  
  333.  
  334.   /* USER TO PLACE CODE HERE */
  335.  
  336.   return(ret_val);
  337. }
  338.